{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "view-in-github" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "S89E1CSUrqEy" }, "source": [ "GOALS:\n", "- Grasp the basic concept of Jacobi, Gauss-Seidel, and Successive Over Relaxation iterative methods\n", "- Understand the pros and cons of each method\n", "- Experience the benefit of iterative solvers" ] }, { "cell_type": "markdown", "metadata": { "id": "vfyRvIambBRs" }, "source": [ "# Jacobi iteration method" ] }, { "cell_type": "markdown", "metadata": { "id": "0hSyDDPmaY2V" }, "source": [ "Begin by writing out the linear system in index form:" ] }, { "cell_type": "markdown", "metadata": { "id": "duqHxM-MaLKK" }, "source": [ "$$\n", "\\begin{align*}\n", "A x &= b \\\\\n", "\\sum_{j} A_{ij} x_j&=b_i \\\\\n", "\\begin{bmatrix}\n", "a_{1,1} & a_{1,2} & ... & a_{1,n}\\\\\n", "a_{2,1} & a_{2,2} & ... & a_{2,n}\\\\\n", "... & ... & ... & ... \\\\\n", "a_{m,1} & a_{m,2} & ... & a_{m,n}\n", "\\end{bmatrix}\\left[\\begin{array}{c} x_1 \\\\x_2 \\\\ ... \\\\x_n \\end{array}\\right] &=\n", "\\left[\\begin{array}{c} b_1 \\\\b_2 \\\\ ... \\\\b_m \\end{array}\\right]\n", "\\end{align*}$$\n", "\n", "Extract the $i$th row, and solve for the diagonal term:\n", "\n", "$$\\begin{aligned}\n", "A_{ii}x_i^{k+1} &+ \\sum_{j \\ne i} A_{ij} x_j^k = b_i \\\\\n", "x_i^{k+1} &= \\frac{1}{A_{ii}}\\left[b_i-\\sum_{j \\ne i} A_{ij} x_j^k\\right]\n", "\\end{aligned}$$\n", "\n", "This makes $x_i^{k+1}$ consistent with all the other elements." ] }, { "cell_type": "markdown", "metadata": { "id": "k8ojCYrjbfUE" }, "source": [ "We can write this in matrix form by pulling appart $A$ along its diagonal, $D$, into the upper $U$ and lower $L$ matricies:\n", "\n", "$A = L + D + U$\n", "\n", "NB: This is not a matrix decomposition; we are literally just pulling it apart (blank elements are zeros):\n", "\n", "$$\\begin{bmatrix} a_{11} & a_{12} & a_{13} \\\\ a_{21} & a_{22} & a_{23} \\\\ a_{31} & a_{32} & a_{33} \\end{bmatrix} = \\begin{bmatrix} & & \\\\ a_{21} & & \\\\ a_{22} & a_{23} & 0 \\end{bmatrix} + \\begin{bmatrix} a_{11} & & \\\\ & a_{22} & \\\\ & & a_{33} \\end{bmatrix} + \\begin{bmatrix} & a_{12} & a_{13} \\\\ & & a_{23} \\\\ & & \\end{bmatrix}\n", "$$\n", "\n", "\n", "\n", "\n", "\n", "The algorithm becomes:\n", "$$\\begin{align}\n", "D x^{k+1} &= b-[L+U]x^k \\\\\n", "x^{k+1} &= D^{-1} \\big[b-[L+U]x^k\\big]\n", "\\end{align} $$" ] }, { "cell_type": "markdown", "metadata": { "id": "YTtkJ_Ftz6cX" }, "source": [ "Note:\n", "- Each new vector uses the *entire* previous one. We need to store both $x^k$ and $x^{k+1}$.\n", "- More memory but parallelizes better!" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "xGezreohYQsl" }, "outputs": [], "source": [ "# prompt: Write a code that take a single Jacobi iteration step\n", "import numpy as np\n", "\n", "def jacobi_step(A, b, x):\n", " \"\"\"Performs a single Jacobi iteration step.\n", "\n", " Args:\n", " A: The coefficient matrix.\n", " b: The right-hand side vector.\n", " x: The current solution vector.\n", "\n", " Returns:\n", " The updated solution vector.\n", " \"\"\"\n", "\n", " n = len(x)\n", " x_new = np.zeros_like(x)\n", " for i in range(n):\n", " x_new[i] = (b[i] - np.dot(A[i, :i], x[:i]) - np.dot(A[i, i + 1:], x[i + 1:])) / A[i, i]\n", " return x_new\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "sq0pcSykYkfK", "outputId": "fd478d90-0400-48d0-dcf0-348e31fa7568" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Residual for [0. 0.] is 7.810249675906654\n", "Residual for [1.25 2. ] is 2.358495283014151\n", "The true answer is [0.81818182 1.72727273]\n" ] } ], "source": [ "# Test it!\n", "A = np.array([[4, 1], [1, 3]])\n", "b = np.array([5, 6])\n", "x0 = np.array([0., 0.])\n", "\n", "print('Residual for ', x0, ' is ', np.linalg.norm(A@x0-b))\n", "\n", "x_new = jacobi_step(A, b, x0)\n", "print('Residual for ', x_new, ' is ', np.linalg.norm(A@x_new-b))\n", "\n", "print('The true answer is ', np.linalg.solve(A, b))" ] }, { "cell_type": "markdown", "metadata": { "id": "tXDsQv-X9RrY" }, "source": [ "# Gauss-Seidel\n", "\n", "Gauss-Seidel uses the same concept except that the next guess for $x_i$ is based on the *current* version of $x$. I.e.: If we are moving downwards through the rows, the $i$th element is updated based on the updated rows above.\n", "\n", "$$\\begin{aligned}\n", "x_i^{k+1} &= \\frac{1}{A_{ii}}\\left[b_i-\\sum_{j=1}^{i-1} A_{ij} x_j^{k+1} -\\sum_{j=i+1}^n A_{ij} x_j^k\\right]\n", "\\end{aligned}$$\n", "\n", "This can again be written in matrix form:\n", "$$\\begin{align}\n", "A_{ii}x_i^{k+1} + \\sum_{j=1}^{i-1} A_{ij} x_j^{k+1} &= b_i-\\sum_{j=i+1}^n A_{ij} x_j^k\\\\\n", "[D + L] x^{k+1} &= b - Ux^{k}\n", "\\end{align}\n", "$$\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "AhXB8B71v_mL" }, "source": [ "Gauss-Seidel is conceptually easier to implement since if we modify $x$ in place, each $x_i^{k+1}$ is built from all the other *current elements*! We can drop the iteration superscript and write (note the arrow for assignment):\n", "\n", "$$\\begin{aligned}\n", "x_i \\leftarrow \\frac{1}{A_{ii}}\\left[b_i-\\sum_{j \\ne i} A_{ij} x_j \\right]\n", "\\end{aligned}$$" ] }, { "cell_type": "markdown", "metadata": { "id": "inHMreFc0yw9" }, "source": [ "Notes:\n", "- Each iteration includes the previously updated elements.\n", "- We can just store 1 vector and update *in-place*.\n", "- Less memory but doesn't parallelize as well." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "InogYRu8cFPW" }, "outputs": [], "source": [ "# prompt: Write a code like above that takes a single Gauss-sidel step\n", "\n", "import numpy as np\n", "def gauss_seidel_step(A, b, x, omega = 1):\n", " \"\"\"Performs a single Gauss-Seidel iteration step.\n", "\n", " Args:\n", " A: The coefficient matrix.\n", " b: The right-hand side vector.\n", " x: The current solution vector.\n", "\n", " Returns:\n", " The updated solution vector.\n", " \"\"\"\n", "\n", " n = len(x)\n", " for i in range(n):\n", " x[i] = (b[i] - np.dot(A[i, :i], x[:i]) - np.dot(A[i, i + 1:], x[i + 1:])) / A[i, i]\n", " return x\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "4ifTX3gDPSsw", "outputId": "a4e3f945-3982-43cc-ad2a-0fc767ca2102" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Residual for [0. 0.] is 7.810249675906654\n", "Residual for [1.25 1.58333333] is 1.583333333333333\n", "The true answer is [0.81818182 1.72727273]\n" ] } ], "source": [ "# Test it!\n", "A = np.array([[4, 1], [1, 3]])\n", "b = np.array([5, 6])\n", "x0 = np.array([0., 0.])\n", "\n", "print('Residual for ', x0, ' is ', np.linalg.norm(A@x0-b))\n", "\n", "x_new = gauss_seidel_step(A, b, x0.copy())\n", "print('Residual for ', x_new, ' is ', np.linalg.norm(A@x_new-b))\n", "\n", "print('The true answer is ', np.linalg.solve(A, b))" ] }, { "cell_type": "markdown", "metadata": { "id": "PRvfzDZq5K_V" }, "source": [ "# Successive Over Relaxation (SOR)" ] }, { "cell_type": "markdown", "metadata": { "id": "eszOcru85Vzs" }, "source": [ "The convergence of Gauss-Sidel can be improved through *relaxation*: Let's take a weighted average of the new and old $x_i^{k+1}$:\n", "\n", "$$\\begin{aligned}\n", "x_i^{k+1} &= \\frac{\\omega}{A_{ii}}\\left[b_i-\\sum_{j=1}^{i-1} A_{ij} x_j^{k+1} -\\sum_{j=i+1}^n A_{ij} x_j^k\\right] + [1-\\omega] x^k_i \\\\\n", "x_i &← \\frac{\\omega}{A_{ii}}\\left[b_i-\\sum_{j \\ne i} A_{ij} x_j \\right] + [1-\\omega] x_i\n", "\\end{aligned}$$\n", "\n", "Let's look at three cases:\n", "- $\\omega = 1$ the method is exactly Gauss-Seidel (therefore you will usually only find SOR out in the wild)\n", "- $\\omega\\lt 1$ the method is *underrelaxed* and will converge / diverge more slowly. Hopefully this will lead to better (albeit slower) convergence...\n", "- $\\omega \\gt 1$ the method is *over relaxed* and convergence / divergence will be accelarated!\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "jmnAYl8tgqcX" }, "source": [ "In general, SOR with a well-chosen $\\omega$ will outperform Gauss-Seidel, but choosing $\\omega$ is not-trivial.\n", "\n", "One option:\n", "Calculate the difference between successive iterations:\n", "\n", "$\\Delta x^k = ||x^{k}-x^{k-1})||$\n", "\n", "After an integer $p$ more iterations, recalculate:\n", "\n", "$\\Delta x^{k+p} =||x^{k+p}-x^{k+p-1}||$\n", "\n", "then the optimal $\\omega$ can be found:\n", "\n", "$\\omega_{opt} \\approx \\frac{2}{1+\\sqrt{1+\\left[ \\frac{\\Delta x^{k+p}}{\\Delta x^{k}} \\right]^p }}$" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "rVkbGHCQV4Bi", "outputId": "9635a4a9-a51a-4486-f12d-27f2e1f59ec7" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Residual for [0. 0.] is 7.810249675906654\n", "Residual for [1.25 1.58333333] is 1.583333333333333\n", "The true answer is [0.81818182 1.72727273]\n" ] } ], "source": [ "# prompt: Write a code that uses the Gauss Seidel function inside a successive over relaxation function to determine step size\n", "\n", "import numpy as np\n", "def sor_step(A, b, x):\n", " \"\"\"Performs a single SOR iteration step.\n", "\n", " Args:\n", " A: The coefficient matrix.\n", " b: The right-hand side vector.\n", " x: The current solution vector.\n", " omega: The relaxation factor.\n", "\n", " Returns:\n", " The updated solution vector.\n", " \"\"\"\n", " omega = 1.05\n", " n = len(x)\n", " for i in range(n):\n", " x[i] = (1 - omega) * x[i] + (omega / A[i, i]) * (b[i] - np.dot(A[i, :i], x[:i]) - np.dot(A[i, i + 1:], x[i + 1:]))\n", " return x\n", "\n", "#Test it!\n", "A = np.array([[4, 1], [1, 3]])\n", "b = np.array([5, 6])\n", "x0 = np.array([0., 0.])\n", "\n", "print('Residual for ', x0, ' is ', np.linalg.norm(A@x0-b))\n", "\n", "x_new = gauss_seidel_step(A, b, x0.copy())\n", "print('Residual for ', x_new, ' is ', np.linalg.norm(A@x_new-b))\n", "\n", "print('The true answer is ', np.linalg.solve(A, b))\n" ] }, { "cell_type": "markdown", "metadata": { "id": "pevq0vu9ikpR" }, "source": [ "# Summary\n", "- Jacobi, Gauss-Seidel, and SOR are all suitable for large, sparse matricies.\n", "- Since the matrix, and therefore the L D U partitions don't change, terms can be precomputed outside of the iteration loop for computational efficiency.\n", "- They generally are more memory efficient and faster but convergence is not guaranteed.\n", "- Even with guaranteed convergence, convergence can be slow.\n", "\n", "**Jacobi**\n", "- Easily parallelized but slower convergence.\n", "- Guaranteed to converge if $A$ is diagonally dominant\n", "\n", "**Gauss-Seidel**\n", "- Faster convergence but doesn't parallelize well.\n", "- Guaranteed to converge if $A$ is diagonally dominant or symmetric ositive definite.\n", "\n", "**Successive Over Relaxation**\n", "- Generalization of Gauss-Seidel ($\\omega = 1$). \n", "- *May* converge faster.\n", "- Success hinges on choice of $\\omega$.\n", "- Shares guaranteed convergence of Gauss-Seidel if $0 \\lt \\omega \\lt 2$." ] }, { "cell_type": "markdown", "metadata": { "id": "-GuiLGEXWXUX" }, "source": [ "# Let's code!\n", "\n", "Let's code in these methods and compare the results. (The python standard libraries don't have implementaitons).\n", "\n", "All the schemes:\n", "1. Start with a guess, $A$ matrix and $b$ vector\n", "2. Do *something* to find a new guess (using A and b)\n", "3. Check how well the guess solves the linear system\n", "4. Repeats (possibly updating a parameter first)\n", "\n", "Define a wrapper that implements the above framework, passing a function to do each step. Let's plot what the system looks like and trace the estimation." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 690 }, "id": "7aVmLUO9Q5iH", "outputId": "741e0506-b073-40f2-e757-cf97ecc396d7" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The true answer is [0.81818182 1.72727273]\n", "Iteration 0 determined [1.25 2. ] with residual 2.358495283014151\n", "Iteration 1 determined [0.75 1.58333333] with residual 0.650854139658888\n", "Iteration 2 determined [0.85416667 1.75 ] with residual 0.19654127358451298\n", "Iteration 3 determined [0.8125 1.71527778] with residual 0.05423784497157428\n", "Iteration 4 determined [0.82118056 1.72916667] with residual 0.016378439465376277\n", "Iteration 5 determined [0.81770833 1.72627315] with residual 0.004519820414298246\n", "Iteration 6 determined [0.81843171 1.72743056] with residual 0.0013648699554481016\n", "Iteration 7 determined [0.81814236 1.72718943] with residual 0.00037665170119081915\n", "Iteration 8 determined [0.81820264 1.72728588] with residual 0.00011373916295438507\n", "Iteration 9 determined [0.81817853 1.72726579] with residual 3.1387641766271184e-05\n", "Iteration 10 determined [0.81818355 1.72727382] with residual 9.47826357947717e-06\n", "Iteration 11 determined [0.81818154 1.72727215] with residual 2.6156368136569228e-06\n", "Iteration 12 determined [0.81818196 1.72727282] with residual 7.898552987055788e-07\n", "Converged after, 12 iterations to: [0.81818196 1.72727282]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "max_iter = 100 # ALWAYS HAVE A FAILSAFE WHEN YOU PLAY WITH INFINITE LOOPS!\n", "tolerance = 1e-6\n", "A = np.array([[4, 1], [1, 3]])\n", "b = np.array([5, 6])\n", "x0 = np.array([0., 0.])\n", "\n", "x_true = np.linalg.solve(A, b)\n", "print('The true answer is ', x_true)\n", "\n", "\n", "# Utility function to autoscale the plot limits to include x0 and x_true\n", "def calculate_box_limits(point1, point2, padding=1.0):\n", " # Extract coordinates\n", " x1, y1 = point1\n", " x2, y2 = point2\n", " # Calculate min and max coordinates with padding\n", " min_x = min(x1, x2) - padding\n", " max_x = max(x1, x2) + padding\n", " min_y = min(y1, y2) - padding\n", " max_y = max(y1, y2) + padding\n", " return (min_x, max_x, min_y, max_y)\n", "\n", "\n", "xb, xe, yb, ye = calculate_box_limits(x0, x_true)\n", "# Plot the linear system\n", "import matplotlib.pyplot as plt\n", "from mpl_toolkits.mplot3d import Axes3D\n", "x = np.linspace(xb, xe, 100)\n", "y = np.linspace(yb, ye, 100)\n", "X, Y = np.meshgrid(x, y)\n", "V = np.stack((X,Y),-1)\n", "Z = np.linalg.norm(np.matmul(V,A.T)-b, axis = -1)\n", "fig, ax = plt.subplots()\n", "CS = ax.contour(X, Y, Z)\n", "ax.clabel(CS, inline=True, fontsize=10)\n", "\n", "\n", "method = jacobi_step\n", "#method = gauss_seidel_step\n", "#method = sor_step\n", "\n", "\n", "for i in range(max_iter):\n", " x_new = method(A, b, x0.copy())\n", " R = np.linalg.norm(A@x_new-b)\n", "\n", " print('Iteration ', i, ' determined ', x_new, 'with residual', R)\n", " plt.plot([x0[0], x_new[0]], [x0[1], x_new[1]], '-o')\n", " if np.linalg.norm(R) < tolerance:\n", " print('Converged after, ', i, ' iterations to: ', x_new)\n", " break\n", " x0 = x_new.copy()\n" ] }, { "cell_type": "markdown", "metadata": { "id": "YUbedhC8nIpR" }, "source": [ "## Example: Iteratively solve a large matrix" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "id": "4NiDpNf5nCxf" }, "outputs": [], "source": [ "# prompt: Form a large, sparse linear system with a diagonally dominant random matrix\n", "\n", "import numpy as np\n", "\n", "def create_diagonally_dominant_matrix(n):\n", " \"\"\"Creates a diagonally dominant random matrix.\n", "\n", " Args:\n", " n: The size of the matrix.\n", "\n", " Returns:\n", " A diagonally dominant random matrix.\n", " \"\"\"\n", "\n", " A = np.random.rand(n, n)\n", " for i in range(n):\n", " A[i, i] = np.sum(np.abs(A[i, :])) + np.random.rand() # Ensure diagonal dominance\n", "\n", " return A\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "id": "-ok0AdcPoJNx" }, "outputs": [], "source": [ "# put this into a function for convenience\n", "def iter_solve(A, b, method):\n", " x0 = np.zeros(b.shape[0])\n", "\n", " max_iter = 1000\n", " tolerance = 1e-6\n", "\n", " for i in range(max_iter):\n", " x_new = method(A, b, x0.copy())\n", " R = np.linalg.norm(A@x_new-b)\n", "\n", " #print('Iteration ', i, ' determined ', x_new, 'with residual', R)\n", " if np.linalg.norm(R) < tolerance:\n", " print('Converged after, ', i, ' iterations.')\n", " break\n", " x0 = x_new.copy()" ] }, { "cell_type": "markdown", "metadata": { "id": "D3yGa4_oR6In" }, "source": [ "### n=4" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "j2YKwwX1nbiV", "outputId": "6c132300-8560-4d50-afab-b29e12f029b5" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LU\n", "90.6 µs ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "Jacobi\n", "Converged after, 18 iterations.\n", "6.07 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "Gauss-Seidel\n", "Converged after, 6 iterations.\n", "1.61 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "SOR\n", "Converged after, 6 iterations.\n", "3.14 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" ] } ], "source": [ "n = 4 # Size of the matrix\n", "A = create_diagonally_dominant_matrix(n)\n", "b = np.random.rand(n) # Create a random right-hand side vector\n", "\n", "print('LU')\n", "%timeit -n1 -r1 np.linalg.solve(A, b)\n", "\n", "print('\\nJacobi')\n", "%timeit -n1 -r1 iter_solve(A, b, jacobi_step)\n", "print('\\nGauss-Seidel')\n", "%timeit -n1 -r1 iter_solve(A, b, gauss_seidel_step)\n", "print('\\nSOR')\n", "%timeit -n1 -r1 iter_solve(A, b, sor_step)" ] }, { "cell_type": "markdown", "metadata": { "id": "kcEmQek1SDTe" }, "source": [ "### n = 100" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "MReXzZosqoJE", "outputId": "1f77a0f7-20d7-44e3-988c-a10d8f85e5c4" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LU\n", "5.24 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "Jacobi\n", "Converged after, 787 iterations.\n", "1.39 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "Gauss-Seidel\n", "Converged after, 10 iterations.\n", "19.4 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "SOR\n", "Converged after, 11 iterations.\n", "12.9 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" ] } ], "source": [ "n = 100 # Size of the matrix\n", "A = create_diagonally_dominant_matrix(n)\n", "b = np.random.rand(n) # Create a random right-hand side vector\n", "\n", "print('LU')\n", "%timeit -n1 -r1 np.linalg.solve(A, b)\n", "\n", "print('\\nJacobi')\n", "%timeit -n1 -r1 iter_solve(A, b, jacobi_step)\n", "print('\\nGauss-Seidel')\n", "%timeit -n1 -r1 iter_solve(A, b, gauss_seidel_step)\n", "print('\\nSOR')\n", "%timeit -n1 -r1 iter_solve(A, b, sor_step)" ] }, { "cell_type": "markdown", "metadata": { "id": "tnjuxw6hSF_D" }, "source": [ "### n = 1000" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "CDecGMQnqpDM", "outputId": "18357eca-4558-4531-fab4-9bae22af63fb" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LU\n", "50.3 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "Gauss-Seidel\n", "Converged after, 10 iterations.\n", "115 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" ] } ], "source": [ "n = 1000 # Size of the matrix\n", "A = create_diagonally_dominant_matrix(n)\n", "b = np.random.rand(n) # Create a random right-hand side vector\n", "\n", "print('LU')\n", "%timeit -n1 -r1 np.linalg.solve(A, b)\n", "\n", "#print('\\nJacobi')\n", "#%timeit -n1 -r1 iter_solve(A, b, jacobi_step)\n", "print('\\nGauss-Seidel')\n", "%timeit -n1 -r1 iter_solve(A, b, gauss_seidel_step)\n", "#print('\\nSOR')\n", "#%timeit -n1 -r1 iter_solve(A, b, sor_step)" ] }, { "cell_type": "markdown", "metadata": { "id": "p9wjWO2DSJ3V" }, "source": [ "### n = 3000" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Xr1oaYC2q14B", "outputId": "4f6d9bd5-1834-4601-da7b-8bb8dcae8263" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LU\n", "692 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "Gauss-Seidel\n", "Converged after, 10 iterations.\n", "411 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" ] } ], "source": [ "n = 3000 # Size of the matrix\n", "A = create_diagonally_dominant_matrix(n)\n", "b = np.random.rand(n) # Create a random right-hand side vector\n", "\n", "print('LU')\n", "%timeit -n1 -r1 np.linalg.solve(A, b)\n", "\n", "#print('\\nJacobi')\n", "#%timeit -n1 -r1 iter_solve(A, b, jacobi_step)\n", "print('\\nGauss-Seidel')\n", "%timeit -n1 -r1 iter_solve(A, b, gauss_seidel_step)\n", "#print('\\nSOR')\n", "#%timeit -n1 -r1 iter_solve(A, b, sor_step)" ] }, { "cell_type": "markdown", "metadata": { "id": "NIpHqLYZSOv6" }, "source": [ "### n = 5000" ] }, { "cell_type": "markdown", "metadata": { "id": "YrIWK23hrXQw" }, "source": [ "HERE WE GO!\n", "Remember, this is a terrible implementation of GS! Numpy with loops is going to be slow!" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "YsoL71_lrFL3", "outputId": "4b8421ae-4b53-4456-f17d-937b23a192af" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LU\n", "2.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n", "\n", "Gauss-Seidel\n", "Converged after, 11 iterations.\n", "874 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" ] } ], "source": [ "n = 5000 # Size of the matrix\n", "A = create_diagonally_dominant_matrix(n)\n", "b = np.random.rand(n) # Create a random right-hand side vector\n", "\n", "print('LU')\n", "%timeit -n1 -r1 np.linalg.solve(A, b)\n", "\n", "#print('\\nJacobi')\n", "#%timeit -n1 -r1 iter_solve(A, b, jacobi_step)\n", "print('\\nGauss-Seidel')\n", "%timeit -n1 -r1 iter_solve(A, b, gauss_seidel_step)\n", "#print('\\nSOR')\n", "#%timeit -n1 -r1 iter_solve(A, b, sor_step)" ] } ], "metadata": { "colab": { "authorship_tag": "ABX9TyOsAjtKSkzSJFLEhzWEYTIb", "include_colab_link": true, "provenance": [], "toc_visible": true }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 0 }